package co.yixiang.modules.tools.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.io.IOException;
import java.util.List;
import java.util.Map;

/**
 * Jackson工具类，用于JSON数据的解析和转换
 */
public class JacksonUtil {

    // 日志对象，用于记录错误信息
    private static final Log logger = LogFactory.getLog(JacksonUtil.class);

    /**
     * 从JSON字符串中解析指定字段的字符串值
     *
     * @param body JSON字符串
     * @param field 目标字段
     * @return 字段的字符串值，如果解析失败或字段不存在则返回null
     */
    public static String parseString(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);
            if (leaf != null) {
                return leaf.asText();
            }
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    /**
     * 从JSON字符串中解析指定字段的字符串列表
     *
     * @param body JSON字符串
     * @param field 目标字段
     * @return 字段的字符串列表，如果解析失败或字段不存在则返回null
     */
    public static List<String> parseStringList(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);

            if (leaf != null) {
                return mapper.convertValue(leaf, new TypeReference<List<String>>() {
                });
            }
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    /**
     * 从JSON字符串中解析指定字段的整数值
     *
     * @param body JSON字符串
     * @param field 目标字段
     * @return 字段的整数值，如果解析失败或字段不存在则返回null
     */
    public static Integer parseInteger(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);
            if (leaf != null) {
                return leaf.asInt();
            }
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    /**
     * 从JSON字符串中解析指定字段的整数列表
     *
     * @param body JSON字符串
     * @param field 目标字段
     * @return 字段的整数列表，如果解析失败或字段不存在则返回null
     */
    public static List<Integer> parseIntegerList(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);

            if (leaf != null) {
                return mapper.convertValue(leaf, new TypeReference<List<Integer>>() {
                });
            }
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    /**
     * 从JSON字符串中解析指定字段的布尔值
     *
     * @param body JSON字符串
     * @param field 目标字段
     * @return 字段的布尔值，如果解析失败或字段不存在则返回null
     */
    public static Boolean parseBoolean(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);
            if (leaf != null) {
                return leaf.asBoolean();
            }
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    /**
     * 从JSON字符串中解析指定字段的短整数值
     *
     * @param body JSON字符串
     * @param field 目标字段
     * @return 字段的短整数值，如果解析失败或字段不存在则返回null
     */
    public static Short parseShort(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);
            if (leaf != null) {
                Integer value = leaf.asInt();
                return value.shortValue();
            }
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    /**
     * 从JSON字符串中解析指定字段的字节值
     *
     * @param body JSON字符串
     * @param field 目标字段
     * @return 字段的字节值，如果解析失败或字段不存在则返回null
     */
    public static Byte parseByte(String body, String field) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node;
        try {
            node = mapper.readTree(body);
            JsonNode leaf = node.get(field);
            if (leaf != null) {
                Integer value = leaf.asInt();
                return value.byteValue();
            }
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    /**
     * 从JSON字符串中解析指定字段的对象
     *
     * @param body JSON字符串
     * @param field 目标字段
     * @param clazz 目标对象的类
     * @param <T> 目标对象的类型
     * @return 解析后的对象，如果解析失败或字段不存在则返回null
     */
    public static <T> T parseObject(String body, String field, Class<T> clazz) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode node;
        try {
            node = mapper.readTree(body);
            node = node.get(field);
            return mapper.treeToValue(node, clazz);
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    /**
     * 将JSON字符串转换为JsonNode对象
     *
     * @param json JSON字符串
     * @return 转换后的JsonNode对象，如果转换失败则返回null
     */
    public static Object toNode(String json) {
        if (json == null) {
            return null;
        }
        ObjectMapper mapper = new ObjectMapper();
        try {
            return mapper.readTree(json);
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    /**
     * 将JSON字符串转换为Map对象，其中键和值都是字符串类型
     *
     * @param data JSON字符串
     * @return 转换后的Map对象，如果转换失败则返回null
     */
    public static Map<String, String> toMap(String data) {
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            return objectMapper.readValue(data, new TypeReference<Map<String, String>>() {
            });
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    /**
     * 将对象转换为JSON字符串
     *
     * @param data 要转换的对象
     * @return 转换后的JSON字符串，如果转换失败则返回null
     */
    public static String toJson(Object data) {
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            return objectMapper.writeValueAsString(data);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}
